{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CTPN+CRNN 算法端到端实现文字识别"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OCR介绍\n",
    "光学字符识别（英语：Optical Character Recognition，OCR）是指对文本资料的图像文件进行分析识别处理，获取文字及版面信息的过程。发展时间较长，使用很普遍。OCR作为计算机视觉中较早使用深度学习技术的领域，有很多优秀的模型出现。普遍的深度学习下的OCR技术将文字识别过程分为：文本区域检测以及字符识别。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 文本区域检测——CTPN模型\n",
    "文字区域检测：将图片中出现的文本位置检测出来，可能存在不同语言，不同文字大小，不同角度倾斜，不同程度遮挡等情况。 \n",
    "CTPN网络结合了CNN与LSTM深度网络，通过固定宽度的anchor提取proposal，能有效的检测出复杂场景的横向分布的文字区域，不定长度文本识别效果较好，是目前使用广泛的文字检测算法。\n",
    "![jupyter](./imgs/1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字符序列检测——CRNN模型\n",
    "字符识别算法：将文本区域的字符识别出来。通过深度神经网络对目标区域进行特征提取，然后对固定特征进行提取和比对，得出识别结果。\n",
    "采用文本识别网络CRNN+CTC。CRNN全称为卷积循环神经网络，将特征提取，序列建模以及转录整合到统一的模型框架中。主要用于端到端地对不定长的文本序列进行识别，不用先对单个文字进行切割，而是将文本识别转化为时序依赖的序列学习问题，就是基于图像的序列识别。\n",
    "如下图，CRNN网络分为：卷积层、循环层和转录层三部分，CTC为无词典的转录方式， 不会被局限在预定义词汇范围中。 \n",
    "![jupyter](./imgs/2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 完整的端到端OCR流程\n",
    "了解了文本区域检测以及字符识别后，下面详细讲解完整的端到端OCR流程：\n",
    "![jupyter](./imgs/3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（1）准备一张含有文字的原图； "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（2）对原图进行文字位置的检测，检测结果可能是水平矩形框，也可能是倾斜矩形框；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（3）从原图中把文字框对应的图片切下来，并旋转正，得到水平的文字块切片图； "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（4）对每个文字块切片图依次进行字符识别，每个切片图的识别结果汇总起来，就得到原图的文字识别结果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因此完整的端到端OCR流程是：输入原图 -> 文字检测 -> 文字块切片 -> 字符识别 -> 识别结果汇总。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "理论部分到此告一段落，下面开始在ModelArts中体验实战项目开发！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 进入ModelArts\n",
    "点击如下链接：https://www.huaweicloud.com/product/modelarts.html ， 进入ModelArts主页。点击“立即使用”按钮，输入用户名和密码登录，进入ModelArts使用页面。\n",
    "\n",
    "## 创建ModelArts notebook\n",
    "下面，我们在ModelArts中创建一个notebook开发环境，ModelArts notebook提供网页版的Python开发环境，可以方便的编写、运行代码，并查看运行结果。\n",
    "\n",
    "第一步：在ModelArts服务主界面依次点击“开发环境”、“创建”"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/4.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二步：如下图勾选notebook配置"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/5.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第三步：配置好notebook参数后，点击下一步，进入notebook信息预览。确认无误后，点击“立即创建”\n",
    "\n",
    "第四步：创建完成后，返回开发环境主界面，等待Notebook创建完毕后，打开Notebook，进行下一步操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 在ModelArts中创建开发环境¶\n",
    "接下来，我们创建一个实际的开发环境，用于后续的实验步骤。\n",
    "\n",
    "第一步：点击下图所示的“打开”按钮，进入刚刚创建的Notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/6.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二步：[点此链接](https://modelarts-labs-bj4.obs.cn-north-4.myhuaweicloud.com:443/notebook/DL_ctpn_crnn/DL_ocr.zip)下载本案例文档DL_ocr.zip到自己的本机，然后按照下图上传压缩包到Notebook中。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/8.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第三步：按照下图新建一个Terminal。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/10.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "按照下图执行 cd work 进入work目录，再执行 unzip DL_ocr.zip，将压缩包进行解压。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/11.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第四步： 回到Notebook文件管理页面，在DL_ocr目录下打开CTPN+CRNN.ipynb文件，进入今天的案例："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/12.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 在Notebook中编写并执行代码\n",
    "在Notebook中，我们输入一个简单的打印语句，然后点击上方的运行按钮，可以查看语句执行的结果："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](./imgs/13.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "开发环境准备好啦，接下来可以愉快地写代码啦！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 下载代码和模型\n",
    "本案例中已经将CTPN和CRNN的代码模型都整合到一起"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successfully download file modelarts-labs-bj4/notebook/DL_ocr_crnn_sequence_recognition/E2E_ocr.zip from OBS to local ./E2E_ocr.zip\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from modelarts.session import Session\n",
    "sess = Session()\n",
    "\n",
    "if sess.region_name == 'cn-north-1':\n",
    "    bucket_path=\"modelarts-labs/notebook/DL_ocr_crnn_sequence_recognition/E2E_ocr.zip\"\n",
    "elif sess.region_name == 'cn-north-4':\n",
    "    bucket_path=\"modelarts-labs-bj4/notebook/DL_ocr_crnn_sequence_recognition/E2E_ocr.zip\"\n",
    "else:\n",
    "    print(\"请更换地区到北京一或北京四\")\n",
    "\n",
    "if not os.path.exists('E2E_ocr'):\n",
    "    sess.download_data(bucket_path=bucket_path, path=\"./E2E_ocr.zip\")\n",
    "\n",
    "if os.path.exists('./E2E_ocr.zip'):\n",
    "    status = os.system(\"unzip -q E2E_ocr.zip\")\n",
    "    if status == 0:\n",
    "        os.system(\"rm E2E_ocr.zip\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. CTPN相关模块导入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "import shutil\n",
    "import cv2\n",
    "import numpy as np\n",
    "import datetime\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "import json\n",
    "import codecs\n",
    "from PIL import Image\n",
    "import tensorflow as tf\n",
    "sys.path.append(os.getcwd() + '/E2E_ocr')\n",
    "sys.path.append(os.getcwd() + '/E2E_ocr/CRNN/')\n",
    "from collections import OrderedDict\n",
    "from tensorflow.contrib import slim\n",
    "\n",
    "from CTPN import data_provider as data_provider\n",
    "from CTPN.model import mean_image_subtraction,Bilstm,lstm_fc,loss\n",
    "from CTPN import vgg\n",
    "from CTPN import model\n",
    "from CTPN.utils.rpn_msr.proposal_layer import proposal_layer\n",
    "from CTPN.utils.text_connector.detectors import TextDetector\n",
    "from CTPN.utils.image import resize_image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. CRNN相关模块安装与导入"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting keras==2.1.6\n",
      "  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/54/e8/eaff7a09349ae9bd40d3ebaf028b49f5e2392c771f294910f75bb608b241/Keras-2.1.6-py2.py3-none-any.whl (339kB)\n",
      "\u001b[K    100% |████████████████████████████████| 348kB 4.1MB/s eta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: pyyaml in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras==2.1.6)\n",
      "Requirement already satisfied: scipy>=0.14 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras==2.1.6)\n",
      "Requirement already satisfied: h5py in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras==2.1.6)\n",
      "Requirement already satisfied: numpy>=1.9.1 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras==2.1.6)\n",
      "Requirement already satisfied: six>=1.9.0 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras==2.1.6)\n",
      "Installing collected packages: keras\n",
      "  Found existing installation: Keras 2.2.4\n",
      "    Uninstalling Keras-2.2.4:\n",
      "      Successfully uninstalled Keras-2.2.4\n",
      "Successfully installed keras-2.1.6\n",
      "\u001b[33mYou are using pip version 9.0.1, however version 20.2.4 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n",
      "Collecting keras_applications==1.0.5\n",
      "  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/3f/9c/6e9393ead970fd97be0cfde912697dafec5800d9191f5ba25352fa537d72/Keras_Applications-1.0.5-py2.py3-none-any.whl (44kB)\n",
      "\u001b[K    100% |████████████████████████████████| 51kB 8.4MB/s eta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: numpy>=1.9.1 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras_applications==1.0.5)\n",
      "Requirement already satisfied: keras>=2.1.6 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras_applications==1.0.5)\n",
      "Requirement already satisfied: h5py in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras_applications==1.0.5)\n",
      "Requirement already satisfied: six>=1.9.0 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras>=2.1.6->keras_applications==1.0.5)\n",
      "Requirement already satisfied: scipy>=0.14 in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras>=2.1.6->keras_applications==1.0.5)\n",
      "Requirement already satisfied: pyyaml in /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages (from keras>=2.1.6->keras_applications==1.0.5)\n",
      "Installing collected packages: keras-applications\n",
      "  Found existing installation: Keras-Applications 1.0.8\n",
      "    Uninstalling Keras-Applications-1.0.8:\n",
      "      Successfully uninstalled Keras-Applications-1.0.8\n",
      "Successfully installed keras-applications-1.0.5\n",
      "\u001b[33mYou are using pip version 9.0.1, however version 20.2.4 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install -i https://pypi.tuna.tsinghua.edu.cn/simple keras==2.1.6\n",
    "!pip install -i https://pypi.tuna.tsinghua.edu.cn/simple keras_applications==1.0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.layers import Flatten, BatchNormalization, Permute, TimeDistributed, Dense, Bidirectional, GRU\n",
    "from keras.layers import Input, Conv2D, MaxPooling2D, ZeroPadding2D,Lambda\n",
    "from keras.models import Model\n",
    "from keras.optimizers import SGD\n",
    "from keras import backend as K\n",
    "\n",
    "import keys as keys\n",
    "from CRNN_model import decode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 加载CTPN模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/util/tf_should_use.py:193: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n",
      "WARNING:tensorflow:From /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n",
      "WARNING:tensorflow:From /home/ma-user/work/case_dev/ocr/E2E_ocr/CTPN/model.py:30: LSTMCell.__init__ (from tensorflow.python.ops.rnn_cell_impl) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "This class is equivalent as tf.keras.layers.LSTMCell, and will be replaced by that in Tensorflow 2.0.\n",
      "WARNING:tensorflow:From /home/ma-user/work/case_dev/ocr/E2E_ocr/CTPN/model.py:33: bidirectional_dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.Bidirectional(keras.layers.RNN(cell))`, which is equivalent to this API\n",
      "WARNING:tensorflow:From /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/ops/rnn.py:443: dynamic_rnn (from tensorflow.python.ops.rnn) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `keras.layers.RNN(cell)`, which is equivalent to this API\n",
      "WARNING:tensorflow:From /home/ma-user/anaconda3/envs/TensorFlow-1.13.1/lib/python3.6/site-packages/tensorflow/python/training/saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use standard file APIs to check for files with this prefix.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CTPN model load success\n"
     ]
    }
   ],
   "source": [
    "checkpoint_path = './E2E_ocr/models/checkpoints/'  # 训练模型保存路径\n",
    "vgg_path = \"./E2E_ocr/models/vgg_16.ckpt\"          # vgg16预训练模型\n",
    "image_path = './E2E_ocr/data/CTW-200'              # 训练集图片路径\n",
    "\n",
    "CHECKPOINT_PATH = './E2E_ocr/models/checkpoints'   # 测试模型保存路径\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '0' #计算设备调用，空值为CPU计算，数字为GPU的序号\n",
    "\n",
    "tf.reset_default_graph()\n",
    "# 定义模型输入信息占位符\n",
    "input_image = tf.placeholder(tf.float32, shape=[None, None, None, 3], name='input_image')\n",
    "input_im_info = tf.placeholder(tf.float32, shape=[None, 3], name='input_im_info')\n",
    "init_op = tf.initialize_all_variables()\n",
    "# 定义模型训练步骤数\n",
    "global_step = tf.variable_scope('global_step', [], initializer=tf.constant_initializer(0))\n",
    "\n",
    "# 加载预训练模型\n",
    "bbox_pred, cls_pred, cls_prob = model.model(input_image)\n",
    "variable_averages = tf.train.ExponentialMovingAverage(0.997, global_step)\n",
    "# 将变量存储到saver中\n",
    "saver = tf.train.Saver(variable_averages.variables_to_restore())\n",
    "\n",
    "ctpn_sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\n",
    "with ctpn_sess.as_default():\n",
    "    # 加载预训练模型权重信息\n",
    "    ckpt_state = tf.train.get_checkpoint_state(CHECKPOINT_PATH)\n",
    "    model_path = os.path.join(CHECKPOINT_PATH, os.path.basename(ckpt_state.model_checkpoint_path))\n",
    "    saver.restore(ctpn_sess, model_path)\n",
    "print('CTPN model load success')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CTPN为了更好检测出文本区域，anchor为 宽度固定为16 ， 高度为[11, 16, 23, 33, 48, 68, 97, 139, 198, 283] 的文本框，共10个anchor。\n",
    "\n",
    "这样的设计是为了更好检测出文字区域的水平位置，在文字检测中，检测文字的水平范围比较垂直范围要更困难。将anchor的宽度固定，只检测10个高度的anchor，尤其在面对多个分离的文本的情况时，能够更好检测文字的范围。\n",
    "\n",
    "不同的anchor得到了边界框，利用nms（非极大值抑制）进行边界框回归计算，最终得到细粒度的文本区域。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 加载CRNN模型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下图给出CRNN的结构参考：\n",
    "![jupyter](./imgs/14.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CRNN model load success\n"
     ]
    }
   ],
   "source": [
    "characters = keys.alphabet[:]\n",
    "nclass=len(characters)+1\n",
    "\n",
    "input = Input(shape=(32, None, 1), name='the_input')\n",
    "# CNN卷积层部分\n",
    "m = Conv2D(64, kernel_size=(3, 3), activation='relu', padding='same', name='conv1')(input)\n",
    "m = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='pool1')(m)\n",
    "m = Conv2D(128, kernel_size=(3, 3), activation='relu', padding='same', name='conv2')(m)\n",
    "m = MaxPooling2D(pool_size=(2, 2), strides=(2, 2), name='pool2')(m)\n",
    "m = Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same', name='conv3')(m)\n",
    "m = Conv2D(256, kernel_size=(3, 3), activation='relu', padding='same', name='conv4')(m)\n",
    "\n",
    "m = ZeroPadding2D(padding=(0, 1))(m)\n",
    "m = MaxPooling2D(pool_size=(2, 2), strides=(2, 1), padding='valid', name='pool3')(m)\n",
    "\n",
    "m = Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', name='conv5')(m)\n",
    "m = BatchNormalization(axis=1)(m)\n",
    "m = Conv2D(512, kernel_size=(3, 3), activation='relu', padding='same', name='conv6')(m)\n",
    "m = BatchNormalization(axis=1)(m)\n",
    "m = ZeroPadding2D(padding=(0, 1))(m)\n",
    "m = MaxPooling2D(pool_size=(2, 2), strides=(2, 1), padding='valid', name='pool4')(m)\n",
    "m = Conv2D(512, kernel_size=(2, 2), activation='relu', padding='valid', name='conv7')(m)\n",
    "\n",
    "m = Permute((2, 1, 3), name='permute')(m)\n",
    "m = TimeDistributed(Flatten(), name='timedistrib')(m)\n",
    "# RNN循环层部分\n",
    "m = Bidirectional(GRU(256, return_sequences=True), name='blstm1')(m)\n",
    "m = Dense(256, name='blstm1_out', activation='linear')(m)\n",
    "m = Bidirectional(GRU(256, return_sequences=True), name='blstm2')(m)\n",
    "y_pred = Dense(nclass, name='blstm2_out', activation='softmax')(m)\n",
    "\n",
    "basemodel = Model(inputs=input, outputs=y_pred)\n",
    "basemodel.load_weights('./E2E_ocr/CRNN/model_crnn.h5')\n",
    "print(\"CRNN model load success\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 定义文字位置检测函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from CTPN.utils.text_connector.text_connect_cfg import Config as TextLineCfg\n",
    "\n",
    "def ctpn_text_detection(img_path):\n",
    "    \"\"\"\n",
    "    CTPN文字位置检测函数\n",
    "    :param img_path: 图片路径\n",
    "    :return: img: 需要进行文字检测的图片\n",
    "    :return: boxes: 图片上检测到的文字框\n",
    "    \"\"\"\n",
    "    try:\n",
    "        im = cv2.imread(img_path)[:, :, ::-1]\n",
    "    except Exception as e:\n",
    "        raise Exception(\"打开图片文件失败，图片路径：\", img_path)\n",
    "    img, (rh, rw) = resize_image(im)  #对图片进行形状调整\n",
    "    h, w, c = img.shape\n",
    "    im_info = np.array([h, w, c]).reshape([1, 3])\n",
    "    #将图片信息传入模型得出预测结果，分别为文字区域坐标以及其得分\n",
    "    bbox_pred_val, cls_prob_val = ctpn_sess.run([bbox_pred, cls_prob],feed_dict={input_image: [img],input_im_info: im_info})\n",
    "    textsegs_total, _ = proposal_layer(cls_prob_val, bbox_pred_val, im_info)\n",
    "    scores = textsegs_total[:, 0]\n",
    "    textsegs = textsegs_total[:, 1:5]\n",
    "    \"\"\"文本框合并策略\"\"\"      \n",
    "    TextLineCfg.MAX_HORIZONTAL_GAP = 50          # 两个框之间的距离小于50，才会被判定为临近框。该值越小，两个框之间要进行合并的要求就越高\n",
    "    TextLineCfg.TEXT_PROPOSALS_MIN_SCORE = 0.7   # 单个小文本框的置信度，高于这个置信度的框才会被合并。该值越大，越多的框就会被丢弃掉\n",
    "    TextLineCfg.TEXT_PROPOSALS_NMS_THRESH = 0.2  # 非极大值抑制阈值。该值越大，越多的框就会被丢弃掉\n",
    "    TextLineCfg.MIN_V_OVERLAPS = 0.7             # 两个框之间的垂直重合度大于0.7，才会被判定为临近框。该值越大，两个在垂直方向上有偏差的框进行合并的可能性就越小\n",
    "    textdetector = TextDetector(DETECT_MODE='H') # DETECT_MODE有两种取值：'H'和'O'，'H'模式适合检测水平文字，'O'模式适合检测有轻微倾斜的文字\n",
    "    \"\"\"文本框合并策略\"\"\" \n",
    "    boxes = textdetector.detect(textsegs, scores[:, np.newaxis], img.shape[:2])\n",
    "    boxes = np.array(boxes, dtype=np.int)\n",
    "    \n",
    "    return img, boxes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. 定义文字块切片函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def img_transform_perspective(image, points, w_pad_rate=(0.0, 0.0), h_pad_rate=(0.0, 0.0)):\n",
    "    \"\"\"\n",
    "    根据四个点进行透视变换，将四个点表示的四边形图变换成水平矩形图\n",
    "    :param image: 原图\n",
    "    :param points: 参考的四个点，坐标顺序是xmin, ymin, xmax, ymin, xmax, ymax, xmin, ymax\n",
    "    :param w_pad_rate: 数组（rate1, rate2），对图像宽度左右两边的扩宽比例\n",
    "    :param h_pad_rate: 数组（rate1, rate2），对图像宽度上下两边的扩宽比例\n",
    "    :return: persp_img: 变换后的图\n",
    "    :return: points2: 变换后的四点\n",
    "    \"\"\"\n",
    "    if not isinstance(points, np.ndarray):\n",
    "        points = np.array(points)\n",
    "    points = points.reshape((4, 2))\n",
    "    widths = np.linalg.norm(points[::2] - points[1::2], axis=1)  # points的4点组成的四边形的上下两边的长度\n",
    "    width = int(round(widths.mean()))\n",
    "    heights = np.linalg.norm(points[:2] - points[3:1:-1], axis=1)  # points的4点组成的四边形的左右两边的长度\n",
    "    height = int(round(heights.mean()))\n",
    "\n",
    "    points2 = np.array([[0, 0], [width - 1, 0],\n",
    "                        [width - 1, height - 1], [0, height - 1]], np.float32)\n",
    "    points2 += np.array([int(width * w_pad_rate[0]), int(height * h_pad_rate[0])]).reshape(1, 2)\n",
    "    size = (int(width * (1 + w_pad_rate[0] + w_pad_rate[1])),\n",
    "            int(height * (1 + h_pad_rate[0] + h_pad_rate[1])))\n",
    "\n",
    "    mat = cv2.getPerspectiveTransform(points.astype(np.float32), points2)\n",
    "    persp_img = cv2.warpPerspective(image, mat, size,\n",
    "                                    borderMode=cv2.BORDER_CONSTANT,\n",
    "                                    borderValue=(255, 255, 255))\n",
    "\n",
    "    return persp_img, points2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. 定义CRNN字符识别函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def crnn_ocr(img):\n",
    "    \"\"\"\n",
    "    CRNN字符识别函数\n",
    "    :param img: 需要进行字符识别的图片\n",
    "    :return: ocr_result: 图片的字符识别结果，数据类型为字符串\n",
    "    \"\"\"\n",
    "    img = img.convert('L')\n",
    " \n",
    "    img = img.convert('L')  # 图片灰度化\n",
    "    \n",
    "    scale = img.size[1] * 1.0 / 32  # 图片尺寸调整，把图片高度调整为32\n",
    "    w = img.size[0] / scale\n",
    "    w = int(w)\n",
    "    img = img.resize((w, 32))\n",
    "    img = np.array(img).astype(np.float32) / 255.0\n",
    "    X = img.reshape((32, w, 1))\n",
    "    X = np.array([X])\n",
    "    y_pred = basemodel.predict(X)  # 预测\n",
    "    ocr_result = decode(y_pred)  # 处理预测结果\n",
    "  \n",
    "    return ocr_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. 查看原图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<PIL.PngImagePlugin.PngImageFile image mode=RGBA size=1051x801 at 0x7F2129F4F630>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img = Image.open('./E2E_ocr/test_dataset/text.png')\n",
    "img"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. 开始图片测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "text.png ocr result:\n",
      "0, A1正在改变我们的生活，\n",
      "1, 正在改变我们身边的各行各业，\n",
      "2, 但是这条通往智能世界的路并不平坦，\n",
      "3, 其中一个巨大鸿沟就是AI人才的稀缺。\n",
      "4, 在中国庞大的I从业群体，\n",
      "5, A开发者缺口达百万级。\n",
      "6, A1将成为全民普及性的技能，\n",
      "7, 所以今天华为云El为大家带来《2020华为云AI实战营》免费课程，\n",
      "8, 大幅降低A1拳习门]椤，\n",
      "9, 帮助庞大的软件开发者群体快速拳握A1技能，\n",
      "10, 把AI用起来。\n",
      "end\n"
     ]
    }
   ],
   "source": [
    "test_dir = './E2E_ocr/test_dataset'  # 待测试图片目录\n",
    "save_results = True\n",
    "output_dir = test_dir + '_output'\n",
    "if not os.path.exists(output_dir):\n",
    "    os.mkdir(output_dir)\n",
    "ocr_results = OrderedDict()\n",
    "files = os.listdir(test_dir)\n",
    "for file_name in files:\n",
    "    if not (file_name.endswith('jpg') or file_name.endswith('png')\n",
    "         or file_name.endswith('JPG') or file_name.endswith('PNG')):\n",
    "            continue\n",
    "    print(file_name, 'ocr result:')\n",
    "    file_path = os.path.join(test_dir, file_name)\n",
    "    \n",
    "    img, boxes = ctpn_text_detection(file_path)  # step1, 检测文字位置\n",
    "    sorted_boxes = sorted(boxes.tolist(), key = lambda x: (x[1], x[0]))  # step2, 对文字框进行排序，优先按文字框左上顶点的y坐标升序排序，其次按x坐标升序排序\n",
    "    for index, box in enumerate(sorted_boxes):\n",
    "        cut_text_img, _ = img_transform_perspective(img, box[:8])  # step3, 从原图上切割出各个文字块，并将倾斜的文字块变换为水平矩形文字块\n",
    "        ocr_result = crnn_ocr(Image.fromarray(cut_text_img))  # step4, 对每个文字块进行字符识别\n",
    "        ocr_results[str(index)] = ocr_result\n",
    "        print(str(index) + ',', ocr_result)\n",
    "        \n",
    "        if save_results:\n",
    "            draw_img = img[:, :, ::-1].copy()\n",
    "            for i, box in enumerate(boxes):\n",
    "                cv2.polylines(draw_img, [box[:8].astype(np.int32).reshape((-1, 1, 2))], True, color=(0, 0, 255), thickness=2)\n",
    "            cv2.imwrite(os.path.join(output_dir, file_name), draw_img)\n",
    "            #将输出结果转为json格式\n",
    "            with codecs.open(os.path.join(output_dir, file_name.split('.')[0] + '.json'), 'w', 'utf-8') as f:\n",
    "                json.dump(ocr_results, f, indent=4, ensure_ascii=False)\n",
    "print('end')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "TensorFlow-1.13.1",
   "language": "python",
   "name": "tensorflow-1.13.1"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
